const express = require('express');
const router = express.Router();
const Multiparty = require('multiparty');
const path = require('path');
const jwt = require('jsonwebtoken');
const axios = require('axios');
const { Schoolmodel, userModel, groupModel, groupMessageModel } = require('../model/model');
const mongoose = require('mongoose');

// 郑康达后端
// 获取学校列表
router.get('/school', async function (req, res) {
  const data = await Schoolmodel.find({});
  res.json({
    data: data,
    code: 200,
    message: '获取学校列表成功'
  });
})

// 获取单个学校信息
router.get('/school/:id', async function (req, res) {
  try {
    const school = await Schoolmodel.findById(req.params.id);
    if (school) {
      res.json({
        data: school,
        code: 200,
        message: '获取学校信息成功'
      });
    } else {
      res.json({
        code: 404,
        message: '学校不存在'
      });
    }
  } catch (error) {
    res.json({
      code: 500,
      message: '获取学校信息失败'
    });
  }
})

// 注册
router.post('/register', async function (req, res) {
  try {
    const { username, studentId, schoolId, password } = req.body;

    // 验证必填字段
    if (!username || !studentId || !schoolId || !password) {
      return res.json({
        code: 400,
        message: '请填写所有必填字段'
      });
    }

    // 获取学校信息并验证学号格式
    const school = await Schoolmodel.findById(schoolId);
    if (!school) {
      return res.json({
        code: 400,
        message: '学校不存在'
      });
    }

    // 验证学号格式
    if (school.studentIdRule) {
      const { pattern, minLength, maxLength } = school.studentIdRule;

      if (studentId.length < minLength || studentId.length > maxLength) {
        return res.json({
          code: 400,
          message: `学号长度应为${minLength}-${maxLength}位`
        });
      }

      if (pattern && !new RegExp(pattern).test(studentId)) {
        return res.json({
          code: 400,
          message: school.studentIdRule.description || '学号格式不正确'
        });
      }
    }

    // 验证用户名和学号在同一学校内的唯一性
    const existingUser = await userModel.findOne({
      $or: [
        { studentId: studentId, schoolId: schoolId },
        { username: username, schoolId: schoolId }
      ]
    });

    if (existingUser) {
      if (existingUser.studentId === studentId) {
        return res.json({
          code: 400,
          message: '该学号已经注册'
        });
      } else if (existingUser.username === username) {
        return res.json({
          code: 400,
          message: '用户名已注册过'
        });
      }
    }

    // 创建新用户
    const newUser = new userModel({
      username,
      studentId,
      schoolId,
      password // 注意：实际项目中应该对密码进行加密
    });

    await newUser.save();

    res.json({
      code: 200,
      message: '注册成功',
      data: {
        userId: newUser._id,
        username: newUser.username,
        studentId: newUser.studentId,
        schoolId: newUser.schoolId
      }
    });

  } catch (error) {
    console.error('注册错误:', error);
    res.json({
      code: 500,
      message: '注册失败，请重试'
    });
  }
});

// 登录接口
router.post('/login', async function (req, res) {
  try {
    const { studentId, password } = req.body;

    // 验证必填字段
    if (!studentId || !password) {
      return res.json({
        code: 400,
        message: '请填写学号和密码'
      });
    }

    // 查找用户
    const user = await userModel.findOne({ studentId });
    if (!user) {
      return res.json({
        code: 400,
        message: '学号不存在'
      });
    }

    // 验证密码（实际项目中应该使用加密密码）
    if (user.password !== password) {
      return res.json({
        code: 400,
        message: '密码错误'
      });
    }

    // 获取用户学校信息
    const school = await Schoolmodel.findById(user.schoolId);

    res.json({
      code: 200,
      message: '登录成功',
      data: {
        userId: user._id,
        username: user.username,
        studentId: user.studentId,
        schoolName: school ? school.name : '',
        schoolId: user.schoolId,
        avatarImage: user.avatarImage,
        isAvatarImageSet: user.isAvatarImageSet
      }
    });

  } catch (error) {
    console.error('登录错误:', error);
    res.json({
      code: 500,
      message: '登录失败，请重试'
    });
  }
});

// 郑康达人脸识别后端(2.0版)
// 引入腾讯云人脸识别包  先下载 npm i tencentcloud-sdk-nodejs-iai
let tencentcloud = require('tencentcloud-sdk-nodejs-iai');
// 活体检测
router.post('/faceLogin', async function (req, res) {
  try {
    const base64 = req.body.base64; //base64是前端传递过来要进行对比的照片的base64格式
    const realName = req.body.realName; // 当前用户的实名信息

    // 检查是否提供了base64数据
    if (!base64) {
      return res.status(400).json({
        code: -4,
        msg: '缺少图像数据',
      });
    }

    // 检查是否提供了实名信息
    if (!realName) {
      return res.status(400).json({
        code: -4,
        msg: '缺少实名信息',
      });
    }

    const IaiClient = tencentcloud.iai.v20200303.Client;

    // 配置参数
    const clientConfig = {
      credential: {
        //密钥和id值  https://console.cloud.tencent.com/cam/capi获取秘钥和id值
        secretId: 'AKIDMZYJp68wVw73nIaeT5TcVCfsseDXdU5U',
        secretKey: 'B9sMbdPyJOK1UhgQyINEpBJCpDNJ0Sgg'
      },
      region: 'ap-beijing', //人脸识别库的地区  华北地区-北京
      profile: {
        httpProfile: {
          endpoint: 'iai.tencentcloudapi.com',
        },
      },
    };

    // 实例化要请求产品的client对象,clientProfile是可选的
    const client = new IaiClient(clientConfig);
    // 直接进行人脸搜索，不做活体检测
    await face(client, base64, res, realName);
  } catch (error) {
    console.error('人脸登录接口错误:', error);
    res.status(500).json({
      code: -5,
      msg: `服务器内部错误: ${error.message}`,
    });
  }
});

// 人脸识别
async function face(client, base64, res, realName) {
  try {
    //请求参数
    const params = {
      GroupIds: [
        //人员库ID 自己创建的人员库ID 替换成自己的
        '1008611',
      ],
      Image: base64, //前端传来的图片base64编码
      NeedPersonInfo: 1, //是否返回人员具体信息。0 为关闭，1 为开启。默认为 0。
      QualityControl: 0, //图片质量控制。 0: 不进行控制； 1:较低的质量要求
      FaceMatchThreshold: 50, //人脸对比度大于50才匹配通过
    };

    //发送请求
    // 人脸搜索的第三方接口
    console.log(client)
    const { Results } = await client.SearchFaces(params);

    // 检查是否有结果
    if (!Results || Results.length === 0 || !Results[0].Candidates) {
      res.json({
        code: -1,
        msg: '没有识别到有效人脸',
      });
      return;
    }

    //判断如果没有匹配到
    if (Results[0].Candidates.length === 0) {
      res.json({
        code: -1,
        msg: '该人员没有注册',
      });
      return;
    }

    //匹配到则返回用户信息
    const { FaceId, Gender, PersonId, PersonName } = Results[0].Candidates[0];
    
    // 身份验证：检查识别到的人脸是否与当前用户的实名信息匹配
    console.log('识别到的人脸姓名:', PersonName);
    console.log('当前用户实名信息:', realName);
    
    if (PersonName !== realName) {
      res.json({
        code: -2,
        msg: '身份验证失败，请确保是本人操作',
      });
      return;
    }

    res.json({
      code: 0,
      data: {
        FaceId,
        Gender,
        PersonId,
        PersonName,
      },
      msg: '身份验证成功',
    });
  } catch (error) {
    console.error('人脸识别出错:', error.message);

    // 根据错误类型返回不同的消息
    if (error.code === 'InvalidParameterValue.NoFaceInPhoto') {
      res.json({
        code: -2,
        msg: '图片中没有检测到人脸，请确保光线充足并正对摄像头',
      });
    } else {
      res.json({
        code: -3,
        msg: '人脸识别服务出错: ' + error.message,
      });
    }
  }
}

// QQ邮箱认证
//邮箱登录
const nodemailer = require('nodemailer');
// 你的QQ邮箱和授权码（不是QQ密码！）
const QQ_USER = '3525551609@qq.com';
const QQ_PASS = 'gfjqavcnfkdfcihe'; // 在QQ邮箱设置-账户-开启SMTP服务获取
// 创建邮件发送器
const transporter = nodemailer.createTransport({
  service: 'qq',
  auth: {
    user: QQ_USER,
    pass: QQ_PASS,
  },
});

// 生成6位数字验证码
function generateCode() {
  return Math.random().toString().slice(2, 8);
}

// 存储验证码（生产环境请用数据库或缓存）
const codeStore = {};
router.post('/send-qq-code', async (req, res) => {
  const { email } = req.body;
  console.log('收到邮箱:', email, 'req.body:', req.body);
  if (!email || !/^[\w-]+@qq\.com$/.test(email)) {
    return res.status(400).json({ code: 1, msg: '请输入有效的QQ邮箱' });
  }
  const code = generateCode();
  codeStore[email] = code;

  try {
    await transporter.sendMail({
      from: QQ_USER,
      to: email,
      subject: '您的验证码',
      text: `您的验证码是：${code},5分钟内有效。`,
      html: `<h2>您的验证码是：<b>${code}</b></h2><p>5分钟内有效。</p>`,
    });
    res.json({ code: 0, msg: '验证码已发送' });
  } catch (err) {
    res.status(500).json({ code: 2, msg: '邮件发送失败', error: err.message });
  }
});

// 获取用户信息接口
router.get('/user/:studentId', async (req, res) => {
  try {
    const { studentId } = req.params;

    if (!studentId) {
      return res.json({ code: 400, msg: '学号不能为空' });
    }

    // 查找用户
    const user = await userModel.findOne({ studentId });
    if (!user) {
      return res.json({ code: 404, msg: '用户不存在' });
    }

    // 获取用户学校信息
    const school = await Schoolmodel.findById(user.schoolId);

    res.json({
      code: 200,
      msg: '获取用户信息成功',
      data: {
        userId: user._id,
        username: user.username,
        studentId: user.studentId,
        schoolName: school ? school.name : '',
        schoolId: user.schoolId,
        avatarImage: user.avatarImage,
        isAvatarImageSet: user.isAvatarImageSet,
        email: user.email
      }
    });
  } catch (error) {
    console.error('获取用户信息错误:', error);
    res.json({ code: 500, msg: '获取用户信息失败' });
  }
});

// 通过用户ID获取用户信息接口
router.get('/userById/:userId', async (req, res) => {
  try {
    const { userId } = req.params;

    if (!userId) {
      return res.json({ code: 400, msg: '用户ID不能为空' });
    }

    // 验证ObjectId格式
    if (!mongoose.Types.ObjectId.isValid(userId)) {
      return res.json({ code: 400, msg: '无效的用户ID格式' });
    }

    // 查找用户
    const user = await userModel.findById(userId);
    if (!user) {
      return res.json({ code: 404, msg: '用户不存在' });
    }

    // 获取用户学校信息
    const school = await Schoolmodel.findById(user.schoolId);

    res.json({
      code: 200,
      msg: '获取用户信息成功',
      data: {
        userId: user._id,
        username: user.username,
        studentId: user.studentId,
        schoolName: school ? school.name : '',
        schoolId: user.schoolId,
        avatarImage: user.avatarImage,
        isAvatarImageSet: user.isAvatarImageSet,
        email: user.email,
        qianming: user.qianming
      }
    });
  } catch (error) {
    console.error('获取用户信息错误:', error);
    res.json({ code: 500, msg: '获取用户信息失败' });
  }
});

// 验证验证码接口
router.post('/verify-qq-code', async (req, res) => {
  try {
    const { email, code } = req.body;

    if (!email || !code) {
      return res.json({ code: 1, msg: '邮箱和验证码不能为空' });
    }

    if (codeStore[email] && codeStore[email] === code) {
      delete codeStore[email];

      // 查找用户并更新邮箱
      const user = await userModel.findOne({ username: req.body.username });
      if (user) {
        user.email = email;
        await user.save();
      }

      return res.json({
        code: 0,
        msg: '邮箱验证成功',
        data: {
          email: email
        }
      });
    } else {
      res.json({ code: 1, msg: '验证码错误或已过期' });
    }
  } catch (error) {
    console.error('邮箱验证错误:', error);
    res.json({ code: 1, msg: '验证失败，请重试' });
  }
});

// 获取QQ扫码二维码
router.get('/qq-qrcode', async (req, res) => {
  try {
    const url = 'https://ssl.ptlogin2.qq.com/ptqrshow?appid=549000912&e=2&l=M&s=3&d=72&v=4&t=' + Math.random() + '&daid=5&pt_3rd_aid=0';
    const response = await axios.get(url, { responseType: 'arraybuffer' });
    // 提取qrsig
    const setCookie = response.headers['set-cookie'] || [];
    const qrsigCookie = setCookie.find(c => c.startsWith('qrsig'));
    const qrsig = qrsigCookie ? qrsigCookie.split(';')[0].split('=')[1] : '';
    // 返回二维码图片base64和qrsig
    const base64 = Buffer.from(response.data, 'binary').toString('base64');
    res.json({ img: 'data:image/png;base64,' + base64, qrsig });
  } catch (err) {
    console.error('获取QQ二维码失败:', err); // 打印完整错误
    res.status(500).json({ msg: '获取二维码失败', error: err.message });
  }
});

// 计算ptqrtoken
function getPtqrToken(qrsig) {
  let e = 0;
  for (let i = 0; i < qrsig.length; ++i) {
    e += (e << 5) + qrsig.charCodeAt(i);
  }
  return 2147483647 & e;
}

// 轮询扫码状态
router.get('/qq-qrcode-status', async (req, res) => {
  const { qrsig, username } = req.query;
  if (!qrsig) return res.status(400).json({ msg: '缺少qrsig' });
  const ptqrtoken = getPtqrToken(qrsig);
  const url = `https://ssl.ptlogin2.qq.com/ptqrlogin?u1=https%3A%2F%2Fqzs.qq.com%2Fqzone%2Fv5%2Floginsucc.html%3Fpara%3Dizone&ptqrtoken=${ptqrtoken}&ptredirect=0&h=1&t=1&g=1&from_ui=1&ptlang=2052&action=0-0-${Date.now()}&js_ver=20032614&js_type=1&login_sig=&pt_uistyle=40&aid=549000912&daid=5&`;
  try {
    const response = await axios.get(url, { headers: { Cookie: `qrsig=${qrsig}` } });
    const text = response.data;
    if (text.includes('二维码未失效')) {
      res.json({ status: 'waiting' });
    } else if (text.includes('二维码认证中')) {
      res.json({ status: 'scanning' });
    } else if (text.includes('二维码已失效')) {
      res.json({ status: 'expired' });
    } else if (text.includes('登录成功')) {
      // 提取QQ号
      const match = text.match(/&uin=(\d+)&/);
      const qq = match ? match[1] : null;
      // 用 username 查找本地用户
      let user = null;
      if (username) {
        user = await userModel.findOne({ username });
      }
      if (user) {
        // 生成token
        const accessToken = jwt.sign({ username: user.username, id: user._id }, '123', { expiresIn: 60 * 15 });
        const refreshToken = jwt.sign({ username: user.username, id: user._id }, '123', { expiresIn: '7d' });
        res.json({
          status: 'success',
          qq,
          accessToken,
          refreshToken,
          userInfo: {
            username: user.username,
            email: user.email,
            avatarImage: user.avatarImage,
            id: user._id
          }
        });
      } else {
        res.json({ status: 'success', qq, msg: '本地未找到该用户，请先注册' });
      }
    } else {
      res.json({ status: 'unknown', text });
    }
  } catch (err) {
    res.status(500).json({ msg: '轮询失败', error: err.message });
  }
});

// 创建群聊
router.post('/groups', async (req, res) => {
  try {
    const { name, members, createdBy } = req.body;

    // 验证必要字段
    if (!name || !members || !createdBy || members.length < 2) {
      return res.json({
        code: 400,
        message: "请提供群聊名称、至少两个成员和创建者ID"
      });
    }

    // 验证创建者是否存在
    const creator = await userModel.findById(createdBy);
    if (!creator) {
      return res.json({
        code: 404,
        message: "创建者不存在"
      });
    }

    // 验证所有成员是否存在且属于同一学校
    const existingMembers = await userModel.find({
      _id: { $in: members },
      schoolId: creator.schoolId // 确保是同一学校
    });
    if (existingMembers.length !== members.length) {
      return res.json({
        code: 400,
        message: "部分成员不存在或不属于同一学校"
      });
    }

    // 创建群聊
    const newGroup = await groupModel.create({
      name,
      members,
      createdBy
    });

    // 返回创建的群聊信息
    const populatedGroup = await groupModel.findById(newGroup._id)
      .populate('members', 'username avatarImage')
      .populate('createdBy', 'username avatarImage');

    res.json({
      code: 200,
      message: "群聊创建成功",
      data: populatedGroup
    });
  } catch (error) {
    console.error('创建群聊失败:', error);
    res.json({
      code: 500,
      message: "服务器错误，创建群聊失败"
    });
  }
});

// 获取用户所在的所有群聊
router.get('/groups', async (req, res) => {
  try {
    const { userId } = req.query;

    if (!userId) {
      return res.json({
        code: 400,
        message: "请提供用户ID"
      });
    }

    // 验证用户是否存在
    const user = await userModel.findById(userId);
    if (!user) {
      return res.json({
        code: 404,
        message: "用户不存在"
      });
    }

    // 查找用户所在的所有群聊
    const groups = await groupModel.find({ members: userId })
      .populate('members', 'username avatarImage')
      .populate('createdBy', 'username avatarImage')
      .sort({ createdAt: -1 });

    // 为每个群聊计算当前用户的未读消息数
    const groupsWithUnreadCount = await Promise.all(
      groups.map(async (group) => {
        // 获取该用户在该群聊中的最后读取时间
        const lastReadTime = group.memberLastRead?.get(userId) || new Date(0);

        // 计算未读消息数（在该用户最后读取时间之后发送的消息）
        const unreadCount = await groupMessageModel.countDocuments({
          groupId: group._id,
          from: { $ne: userId }, // 排除自己发送的消息
          time: { $gt: lastReadTime }
        });

        // 将群聊对象转换为普通对象，并添加未读消息数
        const groupObj = group.toObject();
        groupObj.unreadCount = unreadCount;

        return groupObj;
      })
    );

    res.json({
      code: 200,
      message: "获取群聊列表成功",
      data: groupsWithUnreadCount
    });
  } catch (error) {
    console.error('获取群聊列表失败:', error);
    res.json({
      code: 500,
      message: "服务器错误，获取群聊列表失败"
    });
  }
});

// 获取特定群聊信息
router.get('/groups/:groupId', async (req, res) => {
  try {
    const { groupId } = req.params;

    // 验证ObjectId格式
    if (!mongoose.Types.ObjectId.isValid(groupId)) {
      return res.json({
        code: 400,
        message: "无效的群聊ID格式"
      });
    }

    const group = await groupModel.findById(groupId)
      .populate('members', 'username avatarImage')
      .populate('createdBy', 'username avatarImage');

    if (!group) {
      return res.json({
        code: 404,
        message: "群聊不存在"
      });
    }

    res.json({
      code: 200,
      message: "获取群聊信息成功",
      data: group
    });
  } catch (error) {
    console.error('获取群聊信息失败:', error);
    res.json({
      code: 500,
      message: "服务器错误，获取群聊信息失败"
    });
  }
});
// 发送群聊消息
router.post('/groupMessages', async (req, res) => {
  try {
    const { groupId, from, content, messageType = 'text', audioData, duration, videoData, quote } = req.body;

    // 验证必要字段
    if (!groupId || !from || !content) {
      return res.json({
        code: 400,
        message: "请提供群聊ID、发送者ID和消息内容"
      });
    }

    // 验证消息类型
    if (!['text', 'emoji', 'image', 'voice', 'video', 'system'].includes(messageType)) {
      return res.json({
        code: 400,
        message: '无效的消息类型'
      });
    }

    // 验证群聊和用户是否存在
    const group = await groupModel.findById(groupId);
    if (!group) {
      return res.json({
        code: 404,
        message: "群聊不存在"
      });
    }

    const user = await userModel.findById(from);
    if (!user) {
      return res.json({
        code: 404,
        message: "用户不存在"
      });
    }

    // 验证用户是否在群聊中
    if (!group.members.some(memberId => memberId.toString() === from)) {
      return res.json({
        code: 403,
        message: "您不是该群聊的成员"
      });
    }

    // 创建群聊消息
    const messageData = {
      groupId,
      from,
      content,
      messageType,
      time: new Date(),
      quote: quote || null
    };

    // 如果是语音消息，添加语音相关字段
    if (messageType === 'voice') {
      messageData.audioData = audioData;
      messageData.duration = duration;
    }

    // 如果是视频消息，添加videoData字段
    if (messageType === 'video') {
      if (videoData) messageData.videoData = videoData;
    }

    const message = await groupMessageModel.create(messageData);

    // 更新群聊中其他成员的未读消息数
    const otherMembers = group.members.filter(memberId => memberId.toString() !== from);
    for (const memberId of otherMembers) {
      const currentUnread = group.memberUnreadCount.get(memberId.toString()) || 0;
      group.memberUnreadCount.set(memberId.toString(), currentUnread + 1);
    }
    await group.save();

    // 返回创建的消息信息
    const populatedMessage = await groupMessageModel.findById(message._id)
      .populate('from', 'username avatarImage');

    res.json({
      code: 200,
      message: "消息发送成功",
      data: populatedMessage
    });
  } catch (error) {
    console.error('发送群聊消息失败:', error);
    res.json({
      code: 500,
      message: "服务器错误，发送群聊消息失败"
    });
  }
});

// 获取群聊消息
router.get('/groupMessages/:groupId', async (req, res) => {
  try {
    const { groupId } = req.params;
    const { userId } = req.query; // 添加用户ID参数用于标记已读

    // 验证ObjectId格式
    if (!mongoose.Types.ObjectId.isValid(groupId)) {
      return res.json({
        code: 400,
        message: "无效的群聊ID格式"
      });
    }

    // 验证群聊是否存在
    const group = await groupModel.findById(groupId);
    if (!group) {
      return res.json({
        code: 404,
        message: "群聊不存在"
      });
    }

    // 如果提供了用户ID，更新该用户的最后读取时间并清空未读消息数
    if (userId && group.members.some(memberId => memberId.toString() === userId)) {
      group.memberLastRead.set(userId, new Date());
      group.memberUnreadCount.set(userId, 0);
      await group.save();
    }

    // 获取群聊消息
    const messages = await groupMessageModel.find({ groupId })
      .populate('from', 'username avatarImage')
      .sort({ time: 1 });

    res.json({
      code: 200,
      message: "获取群聊消息成功",
      data: messages
    });
  } catch (error) {
    console.error('获取群聊消息失败:', error);
    res.json({
      code: 500,
      message: "服务器错误，获取群聊消息失败"
    });
  }
});

// 从群聊中移除成员
router.post('/groups/removeMember', async (req, res) => {
  try {
    const { groupId, userId, operatorId } = req.body;

    // 验证必要字段
    if (!groupId || !userId || !operatorId) {
      return res.status(400).json({ msg: "请提供群聊ID、要移除的成员ID和操作者ID" });
    }

    // 验证群聊是否存在
    const group = await groupModel.findById(groupId);
    if (!group) {
      return res.status(404).json({ msg: "群聊不存在" });
    }

    // 验证操作者是否是群主
    if (group.createdBy.toString() !== operatorId) {
      return res.status(403).json({ msg: "只有群主可以移除成员" });
    }

    // 验证要移除的用户是否在群聊中
    if (!group.members.includes(userId)) {
      return res.status(400).json({ msg: "该用户不在群聊中" });
    }

    // 群主不能移除自己
    if (userId === operatorId) {
      return res.status(400).json({ msg: "群主不能移除自己" });
    }

    // 从群聊成员中移除该用户
    await groupModel.findByIdAndUpdate(groupId, {
      $pull: { members: userId }
    });

    // 返回更新后的群聊信息
    const updatedGroup = await groupModel.findById(groupId)
      .populate('members', 'username avatarImage')
      .populate('createdBy', 'username avatarImage');

    res.json(updatedGroup);
  } catch (error) {
    console.error('移除群聊成员失败:', error);
    res.status(500).json({ msg: "服务器错误，移除群聊成员失败" });
  }
});

// 向群聊中添加成员
router.post('/groups/addMembers', async (req, res) => {
  try {
    const { groupId, memberIds, operatorId } = req.body;

    // 验证必要字段
    if (!groupId || !memberIds || !memberIds.length || !operatorId) {
      return res.status(400).json({ msg: "请提供群聊ID、要添加的成员ID列表和操作者ID" });
    }

    // 验证群聊是否存在
    const group = await groupModel.findById(groupId);
    if (!group) {
      return res.status(404).json({ msg: "群聊不存在" });
    }

    // 验证操作者是否在群聊中
    if (!group.members.includes(operatorId)) {
      return res.status(403).json({ msg: "您不是该群聊的成员，无法添加好友" });
    }

    // 获取操作者的学校ID
    const operator = await userModel.findById(operatorId);
    if (!operator) {
      return res.status(404).json({ msg: "操作者不存在" });
    }

    // 过滤掉已经在群聊中的成员
    const newMemberIds = memberIds.filter(id => !group.members.includes(id));

    if (newMemberIds.length === 0) {
      return res.status(400).json({ msg: "所选好友已经在群聊中" });
    }

    // 验证要添加的用户是否存在且属于同一学校
    const usersToAdd = await userModel.find({
      _id: { $in: newMemberIds },
      schoolId: operator.schoolId // 确保是同一学校
    });

    if (usersToAdd.length !== newMemberIds.length) {
      return res.status(400).json({ msg: "部分用户不存在或不属于同一学校" });
    }

    // 向群聊成员中添加新成员
    await groupModel.findByIdAndUpdate(groupId, {
      $addToSet: { members: { $each: newMemberIds } }
    });

    // 返回更新后的群聊信息
    const updatedGroup = await groupModel.findById(groupId)
      .populate('members', 'username avatarImage')
      .populate('createdBy', 'username avatarImage');

    res.json(updatedGroup);
  } catch (error) {
    console.error('添加群聊成员失败:', error);
    res.status(500).json({ msg: "服务器错误，添加群聊成员失败" });
  }
});

// 解散群聊
router.delete('/groups/:groupId', async (req, res) => {
  try {
    const { groupId } = req.params;
    const { operatorId } = req.body;

    // 验证必要字段
    if (!groupId || !operatorId) {
      return res.status(400).json({ msg: "请提供群聊ID和操作者ID" });
    }

    // 验证群聊是否存在
    const group = await groupModel.findById(groupId);
    if (!group) {
      return res.status(404).json({ msg: "群聊不存在" });
    }

    // 验证操作者是否是群主
    if (group.createdBy.toString() !== operatorId) {
      return res.status(403).json({ msg: "只有群主可以解散群聊" });
    }

    // 删除群聊相关的所有消息
    await groupMessageModel.deleteMany({ groupId });

    // 删除群聊
    await groupModel.findByIdAndDelete(groupId);

    res.json({ success: true, msg: "群聊已成功解散" });
  } catch (error) {
    console.error('解散群聊失败:', error);
    res.status(500).json({ msg: "服务器错误，解散群聊失败" });
  }
});

// 获取用户在群聊中的未读消息数
router.get('/groups/:groupId/unread/:userId', async (req, res) => {
  try {
    const { groupId, userId } = req.params;

    // 验证ObjectId格式
    if (!mongoose.Types.ObjectId.isValid(groupId) || !mongoose.Types.ObjectId.isValid(userId)) {
      return res.json({
        code: 400,
        message: "无效的ID格式"
      });
    }

    // 验证群聊是否存在
    const group = await groupModel.findById(groupId);
    if (!group) {
      return res.json({
        code: 404,
        message: "群聊不存在"
      });
    }

    // 验证用户是否在群聊中
    if (!group.members.includes(userId)) {
      return res.json({
        code: 403,
        message: "您不是该群聊的成员"
      });
    }

    // 获取未读消息数
    const unreadCount = group.memberUnreadCount.get(userId) || 0;
    const lastReadTime = group.memberLastRead.get(userId);

    res.json({
      code: 200,
      message: "获取未读消息数成功",
      data: {
        unreadCount,
        lastReadTime
      }
    });
  } catch (error) {
    console.error('获取未读消息数失败:', error);
    res.json({
      code: 500,
      message: "服务器错误，获取未读消息数失败"
    });
  }
});

// 标记群聊消息为已读
router.post('/groups/:groupId/read/:userId', async (req, res) => {
  try {
    const { groupId, userId } = req.params;

    // 验证ObjectId格式
    if (!mongoose.Types.ObjectId.isValid(groupId) || !mongoose.Types.ObjectId.isValid(userId)) {
      return res.json({
        code: 400,
        message: "无效的ID格式"
      });
    }

    // 验证群聊是否存在
    const group = await groupModel.findById(groupId);
    if (!group) {
      return res.json({
        code: 404,
        message: "群聊不存在"
      });
    }

    // 验证用户是否在群聊中
    if (!group.members.includes(userId)) {
      return res.json({
        code: 403,
        message: "您不是该群聊的成员"
      });
    }

    // 更新最后读取时间和清空未读消息数
    group.memberLastRead.set(userId, new Date());
    group.memberUnreadCount.set(userId, 0);
    await group.save();

    res.json({
      code: 200,
      message: "标记已读成功"
    });
  } catch (error) {
    console.error('标记已读失败:', error);
    res.json({
      code: 500,
      message: "服务器错误，标记已读失败"
    });
  }
});

// 获取所有用户列表
router.get('/users', async (req, res) => {
  try {
    const { schoolId } = req.query;

    // 构建查询条件
    const query = {};
    if (schoolId) {
      query.schoolId = schoolId;
    }

    const users = await userModel.find(query, 'username _id avatarImage schoolId');

    res.json({
      code: 200,
      message: "获取用户列表成功",
      data: users
    });
  } catch (error) {
    console.error('获取用户列表失败:', error);
    res.json({
      code: 500,
      message: "服务器错误，获取用户列表失败"
    });
  }
});

module.exports = router;

